tests: Port signalTracker test to jasmine

Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/3164>

diff --git a/tests/meson.build b/tests/meson.build
index c14914c7f2d42650121b058240304bea9625094f..851a9c17cf1e2a5c7f5f0ff666d172e9fada69ed 100644 (file)
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -26,6 +26,7 @@ unit_tests = [
     'jsParse',
     'markup',
     'params',
+    'signalTracker',
 ]
 
 foreach test : unit_tests
@@ -44,7 +45,6 @@ foreach test : unit_tests
 endforeach
 
 legacy_tests = [
-    'signalTracker',
     'url',
     'versionCompare',
 ]

diff --git a/tests/unit/signalTracker.js b/tests/unit/signalTracker.js
index dc1146852ecc8253ac56c509ebfb012c40dea59a..6b2f70b037ee089960d81c3c08d2460b6ed3021b 100644 (file)
--- a/tests/unit/signalTracker.js
+++ b/tests/unit/signalTracker.js
@@ -1,11 +1,8 @@
 // -*- mode: js; js-indent-level: 4; indent-tabs-mode: nil -*-
 
-// Test cases for version comparison
-
 import 'resource:///org/gnome/shell/ui/environment.js';
 import GObject from 'gi://GObject';
 
-const JsUnit = imports.jsUnit;
 import * as Signals from 'resource:///org/gnome/shell/misc/signals.js';
 
 import {TransientSignalHolder, registerDestroyableType} from 'resource:///org/gnome/shell/misc/signalTracker.js';
@@ -16,99 +13,168 @@ const Destroyable = GObject.registerClass({
 registerDestroyableType(Destroyable);
 
 const GObjectEmitter = GObject.registerClass({
-    Signals: {'signal': {}},
+    Signals: {
+        'signal1': {},
+        'signal2': {},
+    },
 }, class GObjectEmitter extends Destroyable {});
 
-const emitter1 = new Signals.EventEmitter();
-const emitter2 = new GObjectEmitter();
-
-const tracked1 = new Destroyable();
-const tracked2 = {};
-
-let transientHolder;
-let count = 0;
-const handler = () => count++;
-
-emitter1.connectObject('signal', handler, tracked1);
-emitter2.connectObject('signal', handler, tracked1);
-
-emitter1.connectObject('signal', handler, tracked2);
-emitter2.connectObject('signal', handler, tracked2);
-
-JsUnit.assertEquals(count, 0);
-
-emitter1.emit('signal');
-emitter2.emit('signal');
-
-JsUnit.assertEquals(count, 4);
-
-tracked1.emit('destroy');
-
-emitter1.emit('signal');
-emitter2.emit('signal');
-
-JsUnit.assertEquals(count, 6);
-
-emitter1.disconnectObject(tracked2);
-emitter2.emit('destroy');
-
-emitter1.emit('signal');
-emitter2.emit('signal');
-
-JsUnit.assertEquals(count, 6);
-
-emitter1.connectObject(
-    'signal', handler,
-    'signal', handler, GObject.ConnectFlags.AFTER,
-    tracked1);
-emitter2.connectObject(
-    'signal', handler,
-    'signal', handler, GObject.ConnectFlags.AFTER,
-    tracked1);
-
-emitter1.emit('signal');
-emitter2.emit('signal');
-
-JsUnit.assertEquals(count, 10);
-
-tracked1.emit('destroy');
-emitter1.emit('signal');
-emitter2.emit('signal');
-
-JsUnit.assertEquals(count, 10);
-
-emitter1.connectObject('signal', handler, tracked1);
-emitter2.connectObject('signal', handler, tracked1);
-
-transientHolder = new TransientSignalHolder(tracked1);
-
-emitter1.connectObject('signal', handler, transientHolder);
-emitter2.connectObject('signal', handler, transientHolder);
-
-emitter1.emit('signal');
-emitter2.emit('signal');
-
-JsUnit.assertEquals(count, 14);
-
-transientHolder.destroy();
-
-emitter1.emit('signal');
-emitter2.emit('signal');
-
-JsUnit.assertEquals(count, 16);
-
-transientHolder = new TransientSignalHolder(tracked1);
-
-emitter1.connectObject('signal', handler, transientHolder);
-emitter2.connectObject('signal', handler, transientHolder);
-
-emitter1.emit('signal');
-emitter2.emit('signal');
-
-JsUnit.assertEquals(count, 20);
+describe('connectObject()', () => {
+    let gobjectEmitter, eventEmitter;
+    let trackedObject;
 
-tracked1.emit('destroy');
-emitter1.emit('signal');
-emitter2.emit('signal');
+    beforeEach(() => {
+        gobjectEmitter = new GObjectEmitter();
+        eventEmitter = new Signals.EventEmitter();
+
+        trackedObject = {};
+    });
+
+    it('connects to GObject signals', () => {
+        const handler = jasmine.createSpy();
+
+        gobjectEmitter.connectObject('signal1', handler, trackedObject);
+        gobjectEmitter.emit('signal1');
+
+        expect(handler).toHaveBeenCalled();
+    });
+
+    it('connects to EventEmitter signals', () => {
+        const handler = jasmine.createSpy();
+
+        eventEmitter.connectObject('signal1', handler, trackedObject);
+        eventEmitter.emit('signal1');
 
-JsUnit.assertEquals(count, 20);
+        expect(handler).toHaveBeenCalled();
+    });
+
+    it('can connect multiple GObject signals', () => {
+        const handler1 = jasmine.createSpy();
+        const handler2 = jasmine.createSpy();
+
+        gobjectEmitter.connectObject(
+            'signal1', handler1,
+            'signal2', handler2,
+            trackedObject);
+        gobjectEmitter.emit('signal1');
+        gobjectEmitter.emit('signal2');
+
+        expect(handler1).toHaveBeenCalled();
+        expect(handler2).toHaveBeenCalled();
+    });
+
+    it('can connect multiple EventEmitter signals', () => {
+        const handler1 = jasmine.createSpy();
+        const handler2 = jasmine.createSpy();
+
+        eventEmitter.connectObject(
+            'signal1', handler1,
+            'signal2', handler2,
+            trackedObject);
+        eventEmitter.emit('signal1');
+        eventEmitter.emit('signal2');
+
+        expect(handler1).toHaveBeenCalled();
+        expect(handler2).toHaveBeenCalled();
+    });
+
+    it('supports ConnectFlags for GObject signals', () => {
+        const handler1 = jasmine.createSpy();
+        const handler2 = jasmine.createSpy();
+
+        gobjectEmitter.connectObject(
+            'signal1', handler1,
+            'signal2', handler2, GObject.ConnectFlags.AFTER,
+            trackedObject);
+        gobjectEmitter.emit('signal1');
+        gobjectEmitter.emit('signal2');
+
+        expect(handler1).toHaveBeenCalled();
+        expect(handler2).toHaveBeenCalled();
+    });
+
+    it('supports ConnectFlags for EventEmitter signals', () => {
+        const handler1 = jasmine.createSpy();
+        const handler2 = jasmine.createSpy();
+
+        eventEmitter.connectObject(
+            'signal1', handler1,
+            'signal2', handler2, GObject.ConnectFlags.AFTER,
+            trackedObject);
+        eventEmitter.emit('signal1');
+        eventEmitter.emit('signal2');
+
+        expect(handler1).toHaveBeenCalled();
+        expect(handler2).toHaveBeenCalled();
+    });
+});
+
+describe('disconnectObject()', () => {
+    let emitter;
+    let trackedDestroyable, trackedObject;
+
+    beforeEach(() => {
+        emitter = new GObjectEmitter();
+
+        trackedDestroyable = new Destroyable();
+        trackedObject = {};
+    });
+
+    it('disconnects signals by tracked object', () => {
+        const handler = jasmine.createSpy();
+
+        emitter.connectObject(
+            'signal1', handler,
+            'signal2', handler,
+            trackedObject);
+        emitter.disconnectObject(trackedObject);
+        emitter.emit('signal1');
+        emitter.emit('signal2');
+
+        expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('is called when a tracked destroyable is destroyed', () => {
+        const handler = jasmine.createSpy();
+
+        emitter.connectObject('signal1', handler, trackedDestroyable);
+        trackedDestroyable.emit('destroy');
+        emitter.emit('signal1');
+
+        expect(handler).not.toHaveBeenCalled();
+    });
+});
+
+describe('TransientSignalHolder', () => {
+    let emitter;
+    let tracked, transientHolder;
+
+    beforeEach(() => {
+        emitter = new GObjectEmitter();
+        tracked = new Destroyable();
+        transientHolder = new TransientSignalHolder(tracked);
+    });
+
+    it('destroys with its owner', () => {
+        const handler = jasmine.createSpy();
+
+        emitter.connectObject('signal1', handler, transientHolder);
+        tracked.emit('destroy');
+        emitter.emit('signal1');
+
+        expect(handler).not.toHaveBeenCalled();
+    });
+
+    it('can be destroyed without affecting its owner', () => {
+        const handler1 = jasmine.createSpy();
+        const handler2 = jasmine.createSpy();
+
+        emitter.connectObject('signal1', handler1, tracked);
+        emitter.connectObject('signal1', handler2, transientHolder);
+        transientHolder.destroy();
+        emitter.emit('signal1');
+
+        expect(handler1).toHaveBeenCalled();
+        expect(handler2).not.toHaveBeenCalled();
+    });
+});